Contents
- Eff <RT, A> (ReaderT<RT, IO, A> effect)
- Pure (A value)
- Fail (Error error)
- Lift (Func<RT, Either<Error, A>> f)
- Lift (Func<RT, Fin<A>> f)
- Lift (Func<RT, A> f)
- LiftIO (Func<RT, Task<A>> f)
- LiftIO (Func<RT, Task<Fin<A>>> f)
- LiftIO (Func<RT, IO<A>> f)
- Lift (Func<Either<Error, A>> f)
- Lift (Func<Fin<A>> f)
- Lift (Func<A> f)
- LiftIO (Func<Task<A>> f)
- LiftIO (Func<Task<Fin<A>>> f)
- LiftIO (IO<A> ma)
- Map <B> (Func<A, B> f)
- Select <B> (Func<A, B> f)
- MapFail (Func<Error, Error> f)
- MapIO <B> (Func<IO<A>, IO<B>> f)
- BiMap <B> (Func<A, B> Succ, Func<Error, Error> Fail)
- Match <B> (Func<A, B> Succ, Func<Error, B> Fail)
- IfFail (Func<Error, A> Fail)
- IfFailEff (Func<Error, K<Eff<RT>, A>> Fail)
- IfFailEff (Func<Error, K<Eff, A>> Fail)
- Filter (Func<A, bool> predicate)
- Where (Func<A, bool> predicate)
- Bind <B> (Func<A, Eff<RT, B>> f)
- Bind <B> (Func<A, IO<B>> f)
- Bind <B> (Func<A, Ask<RT, B>> f)
- Bind <B> (Func<A, K<Eff<RT>, B>> f)
- Bind <B> (Func<A, Pure<B>> f)
- Bind (Func<A, Fail<Error>> f)
- Bind <B> (Func<A, Eff<B>> f)
- Bind <B> (Func<A, K<Eff, B>> f)
- SelectMany <B, C> (Func<A, Eff<RT, B>> bind, Func<A, B, C> project)
- SelectMany <B, C> (Func<A, K<Eff<RT>, B>> bind, Func<A, B, C> project)
- SelectMany <B, C> (Func<A, Pure<B>> bind, Func<A, B, C> project)
- SelectMany <B, C> (Func<A, IO<B>> bind, Func<A, B, C> project)
- SelectMany <B, C> (Func<A, Ask<RT, B>> bind, Func<A, B, C> project)
- SelectMany <B, C> (Func<A, Fail<Error>> bind, Func<A, B, C> project)
- SelectMany <C> (Func<A, Guard<Error, Unit>> bind, Func<A, Unit, C> project)
- SelectMany <C> (Func<A, Guard<Fail<Error>, Unit>> bind, Func<A, Unit, C> project)
- SelectMany <B, C> (Func<A, Eff<B>> bind, Func<A, B, C> project)
- SelectMany <B, C> (Func<A, K<Eff, B>> bind, Func<A, B, C> project)
- Success (A value)
- Effect (Func<RT, A> f)
- EffectMaybe (Func<RT, Fin<A>> f)
- ToString ()
- Eff
- Success <RT, A> (A value)
- Fail <RT, A> (Error error)
- unit <RT> ()
- runtime <RT> ()
- getState <RT> ()
- localCancel <RT, A> (Eff<RT, A> ma)
- local <OuterRT, InnerRT, A> (Func<OuterRT, InnerRT> f, Eff<InnerRT, A> ma)
- lift <RT, A> (Func<RT, Either<Error, A>> f)
- lift <RT, A> (Func<RT, Fin<A>> f)
- lift <RT, A> (Func<RT, A> f)
- lift <RT, A> (Func<RT, Task<A>> f)
- lift <RT, A> (Func<RT, Task<Fin<A>>> f)
- lift <RT, A> (IO<A> ma)
Sub modules
| Extensions |
| Operators |
| Prelude |
record Eff <RT, A> (ReaderT<RT, IO, A> effect) Source #
This monad is used to encapsulate side effects, exception capture, and dependency-injection via the RT runtime.
Parameters
| type | RT | Runtime type |
| type | A | Bound value type |
Methods
method Eff<RT, B> Map <B> (Func<A, B> f) Source #
Maps the Eff monad if it's in a success state
Parameters
| param | f | Function to map the success value with |
| returns | Mapped | |
method Eff<RT, B> Select <B> (Func<A, B> f) Source #
Maps the Eff monad if it's in a success state
Parameters
| param | f | Function to map the success value with |
| returns | Mapped | |
method Eff<RT, A> MapFail (Func<Error, Error> f) Source #
Maps the Eff monad if it's in a success state
Parameters
| param | f | Function to map the success value with |
| returns | Mapped | |
method Eff<RT, B> MapIO <B> (Func<IO<A>, IO<B>> f) Source #
Maps the inner IO monad
Parameters
| param | f | Function to map with |
| returns | Mapped | |
method Eff<RT, B> BiMap <B> (Func<A, B> Succ, Func<Error, Error> Fail) Source #
Mapping of either the Success state or the Failure state depending on what
state this Eff monad is in.
Parameters
| param | Succ | Mapping to use if the |
| param | Fail | Mapping to use if the |
| returns | Mapped | |
method Eff<RT, B> Match <B> (Func<A, B> Succ, Func<Error, B> Fail) Source #
Pattern match the success or failure values and collapse them down to a success value
Parameters
| param | Succ | Success value mapping |
| param | Fail | Failure value mapping |
| returns | IO in a success state | |
method Eff<RT, A> IfFail (Func<Error, A> Fail) Source #
Map the failure to a success value
Parameters
| param | f | Function to map the fail value |
| returns | IO in a success state | |
method Eff<RT, A> IfFailEff (Func<Error, K<Eff<RT>, A>> Fail) Source #
Map the failure to a new IO effect
Parameters
| param | f | Function to map the fail value |
| returns | IO that encapsulates that IfFail | |
method Eff<RT, A> IfFailEff (Func<Error, K<Eff, A>> Fail) Source #
Map the failure to a new IO effect
Parameters
| param | f | Function to map the fail value |
| returns | IO that encapsulates that IfFail | |
method Eff<RT, A> Filter (Func<A, bool> predicate) Source #
Only allow values through the effect if the predicate returns true for the bound value
Parameters
| param | predicate | Predicate to apply to the bound value> |
| returns | Filtered IO | |
method Eff<RT, A> Where (Func<A, bool> predicate) Source #
Only allow values through the effect if the predicate returns true for the bound value
Parameters
| param | predicate | Predicate to apply to the bound value> |
| returns | Filtered IO | |
method Eff<RT, B> Bind <B> (Func<A, Eff<RT, B>> f) Source #
Monadic bind operation. This runs the current Eff monad and feeds its result to the
function provided; which in turn returns a new Eff monad. This can be thought of as
chaining IO operations sequentially.
Parameters
| param | f | Bind operation |
| returns | Composition of this monad and the result of the function provided | |
method Eff<RT, B> Bind <B> (Func<A, IO<B>> f) Source #
Monadic bind operation. This runs the current Eff monad and feeds its result to the
function provided; which in turn returns a new Eff monad. This can be thought of as
chaining IO operations sequentially.
Parameters
| param | f | Bind operation |
| returns | Composition of this monad and the result of the function provided | |
method Eff<RT, B> Bind <B> (Func<A, Ask<RT, B>> f) Source #
Monadic bind operation. This runs the current Eff monad and feeds its result to the
function provided; which in turn returns a new Eff monad. This can be thought of as
chaining IO operations sequentially.
Parameters
| param | f | Bind operation |
| returns | Composition of this monad and the result of the function provided | |
method Eff<RT, B> Bind <B> (Func<A, K<Eff<RT>, B>> f) Source #
Monadic bind operation. This runs the current Eff monad and feeds its result to the
function provided; which in turn returns a new Eff monad. This can be thought of as
chaining IO operations sequentially.
Parameters
| param | f | Bind operation |
| returns | Composition of this monad and the result of the function provided | |
method Eff<RT, B> Bind <B> (Func<A, Pure<B>> f) Source #
Monadic bind operation. This runs the current Eff monad and feeds its result to the
function provided; which in turn returns a new Eff monad. This can be thought of as
chaining IO operations sequentially.
Parameters
| param | f | Bind operation |
| returns | Composition of this monad and the result of the function provided | |
method Eff<RT, A> Bind (Func<A, Fail<Error>> f) Source #
Monadic bind operation. This runs the current Eff monad and feeds its result to the
function provided; which in turn returns a new Eff monad. This can be thought of as
chaining IO operations sequentially.
Parameters
| param | f | Bind operation |
| returns | Composition of this monad and the result of the function provided | |
method Eff<RT, B> Bind <B> (Func<A, Eff<B>> f) Source #
Monadic bind operation. This runs the current Eff monad and feeds its result to the
function provided; which in turn returns a new Eff monad. This can be thought of as
chaining IO operations sequentially.
Parameters
| param | f | Bind operation |
| returns | Composition of this monad and the result of the function provided | |
method Eff<RT, B> Bind <B> (Func<A, K<Eff, B>> f) Source #
Monadic bind operation. This runs the current Eff monad and feeds its result to the
function provided; which in turn returns a new Eff monad. This can be thought of as
chaining IO operations sequentially.
Parameters
| param | f | Bind operation |
| returns | Composition of this monad and the result of the function provided | |
method Eff<RT, C> SelectMany <B, C> (Func<A, Eff<RT, B>> bind, Func<A, B, C> project) Source #
Monadic bind operation. This runs the current Eff monad and feeds its result to the
function provided; which in turn returns a new Eff monad. This can be thought of as
chaining IO operations sequentially.
Parameters
| param | bind | Bind operation |
| returns | Composition of this monad and the result of the function provided | |
method Eff<RT, C> SelectMany <B, C> (Func<A, K<Eff<RT>, B>> bind, Func<A, B, C> project) Source #
Monadic bind operation. This runs the current Eff monad and feeds its result to the
function provided; which in turn returns a new Eff monad. This can be thought of as
chaining IO operations sequentially.
Parameters
| param | bind | Bind operation |
| returns | Composition of this monad and the result of the function provided | |
method Eff<RT, C> SelectMany <B, C> (Func<A, Pure<B>> bind, Func<A, B, C> project) Source #
Monadic bind operation. This runs the current Eff monad and feeds its result to the
function provided; which in turn returns a new Eff monad. This can be thought of as
chaining IO operations sequentially.
Parameters
| param | bind | Bind operation |
| returns | Composition of this monad and the result of the function provided | |
method Eff<RT, C> SelectMany <B, C> (Func<A, IO<B>> bind, Func<A, B, C> project) Source #
Monadic bind operation. This runs the current Eff monad and feeds its result to the
function provided; which in turn returns a new Eff monad. This can be thought of as
chaining IO operations sequentially.
Parameters
| param | bind | Bind operation |
| returns | Composition of this monad and the result of the function provided | |
method Eff<RT, C> SelectMany <B, C> (Func<A, Ask<RT, B>> bind, Func<A, B, C> project) Source #
Monadic bind operation. This runs the current Eff monad and feeds its result to the
function provided; which in turn returns a new Eff monad. This can be thought of as
chaining IO operations sequentially.
Parameters
| param | bind | Bind operation |
| returns | Composition of this monad and the result of the function provided | |
method Eff<RT, C> SelectMany <B, C> (Func<A, Fail<Error>> bind, Func<A, B, C> project) Source #
Monadic bind operation. This runs the current Eff monad and feeds its result to the
function provided; which in turn returns a new Eff monad. This can be thought of as
chaining IO operations sequentially.
Parameters
| param | bind | Bind operation |
| returns | Composition of this monad and the result of the function provided | |
method Eff<RT, C> SelectMany <C> (Func<A, Guard<Error, Unit>> bind, Func<A, Unit, C> project) Source #
Monadic bind operation. This runs the current Eff monad and feeds its result to the
function provided; which in turn returns a new Eff monad. This can be thought of as
chaining IO operations sequentially.
Parameters
| param | bind | Bind operation |
| returns | Composition of this monad and the result of the function provided | |
method Eff<RT, C> SelectMany <C> (Func<A, Guard<Fail<Error>, Unit>> bind, Func<A, Unit, C> project) Source #
Monadic bind operation. This runs the current Eff monad and feeds its result to the
function provided; which in turn returns a new Eff monad. This can be thought of as
chaining IO operations sequentially.
Parameters
| param | bind | Bind operation |
| returns | Composition of this monad and the result of the function provided | |
method Eff<RT, C> SelectMany <B, C> (Func<A, Eff<B>> bind, Func<A, B, C> project) Source #
Monadic bind operation. This runs the current Eff monad and feeds its result to the
function provided; which in turn returns a new Eff monad. This can be thought of as
chaining IO operations sequentially.
Parameters
| param | bind | Bind operation |
| returns | Composition of this monad and the result of the function provided | |
method Eff<RT, C> SelectMany <B, C> (Func<A, K<Eff, B>> bind, Func<A, B, C> project) Source #
Monadic bind operation. This runs the current Eff monad and feeds its result to the
function provided; which in turn returns a new Eff monad. This can be thought of as
chaining IO operations sequentially.
Parameters
| param | bind | Bind operation |
| returns | Composition of this monad and the result of the function provided | |
method Eff<RT, A> EffectMaybe (Func<RT, Fin<A>> f) Source #
Lift a synchronous effect into the Eff monad
Methods
method Eff<RT, A> Success <RT, A> (A value) Source #
Construct a successful effect with a pure value
Parameters
| type | A | Bound value type |
| param | value | Pure value to construct the monad with |
| returns | Synchronous IO monad that captures the pure value | |
method Eff<RT, A> Fail <RT, A> (Error error) Source #
Construct a failed effect
Parameters
| type | A | Bound value type |
| param | error | Error that represents the failure |
| returns | Synchronous IO monad that captures the failure | |
method Eff<RT, (RT Runtime, EnvIO EnvIO)> getState <RT> () Source #
Get all the internal state of the Eff
method Eff<RT, A> localCancel <RT, A> (Eff<RT, A> ma) Source #
Create a new cancellation context and run the provided Aff in that context
Parameters
| type | RT | Runtime environment |
| type | A | Bound value type |
| param | ma | Operation to run in the next context |
| returns | An asynchronous effect that captures the operation running in context | |
method Eff<OuterRT, A> local <OuterRT, InnerRT, A> (Func<OuterRT, InnerRT> f, Eff<InnerRT, A> ma) Source #
Create a new local context for the environment by mapping the outer environment and then using the result as a new context when running the IO monad provided
Parameters
| param | f | Function to map the outer environment into a new one to run |
| param | ma | IO monad to run in the new context |
method Eff<RT, A> lift <RT, A> (Func<RT, Either<Error, A>> f) Source #
Lift an effect into the Eff monad